Lecture des tableaux de données

Dans un premier temps, nous allons ajouter les données nécessaires au projet grâce à la commande “read.csv”. Nous allons donc insérer les fichiers contenant l’ensemble des codes APE propres aux commerces ainsi que l’extrait de la base Sirène du département 42. Il est à noter qu’au préalable, un projet R a été créé afin de définir le répertoire de travail, pour éviter d’indiquer le chemin d’accès de tous les fichiers. En insérant les fichiers, nous leur donnont un nom plus court.

data42 = read.csv("geo_siret_42.csv")
APE_type = read.csv("APE_Type.csv")

Voici les 5 premières lignes de la table APE_type, qui montre la correspondance entre le code APE, le nom complet de la catégorie ainsi qu’un nom plus générique.

Classification des commerces de la Loire

Nous allons ensuite, dans un second temps, utiliser les données des entreprises de la Loire (42) insérées principalement afin d’en présenter quelques données statistiques. Par exemple, le nombre de boulangeries peut être calculé en “comptant” le nombre d’occurences du mot “BOULANGERIE” dans la colonne indiquant les noms des établissements.

sum(str_count(data42$enseigne1Etablissement, pattern = "BOULANGERIE"))

## [1] 84

Le résultat est donc un total de 84 boulangeries dans le 42.

Nous allons ensuite modifier les données de ce tableau afin de mieux les faire correspondre à celles présentes dans APE_type, pour une future jointure. Pour cela, nous allons transformer le “code activité” afin de ne garder que les 4 premiers caractères. La fonction “subset” de la librairie “stringr” est tout à fait indiquée pour cette manipulation puisqu’elle permet de ne garder qu’un certain nombre de caractères d’une colonne existante (ici les caractères 1 à 4 de “activitePrincipaleEtablissement” contenant les codes). Ce nouveau code est stocké dans une nouvelle colonne, de data42, la colonne “Code”.

data42$Code = str_sub(data42$activitePrincipaleEtablissement,start=1,end=4)

Enfin, nous allons filtrer nos données afin de ne garder que les commerces. Puisque la table “APE_type” contient l’ensemble des codes que nous souhaitons garder, nous allons créer un filtre afin de ne garder que les lignes de “data42” ayant ces mêmes codes. Les données restantes seront stockées dans une nouvelle table. Enfin, nous allons ajouter l’intitulé des codes à cette nouvelle table, issus de la table “APE_type”, via une jointure attributaire.

alim42 = filter(data42, data42$Code %in% APE_type$Code)
data42_alim = merge(alim42, APE_type, by=c("Code", "Code"))

Statistiques et classements des communes

Grâce à ce filtre et à ces nouveaux intitulés, nous pouvons maintenant effectuer de nouvelles analyses. Par exemple, nous allons calculer le nombre de commerces par commune, puis classer les classer en fonction du résultat. Pour cela, nous allons utiliser des fonctions de résumé, qui permet en particulier de regrouper les données en fonction de valeurs communes dans une colonne. Elle permet aussi d’effectuer un calcul sur la colonne qui fait l’objet du “regroupement”. Ici, nous allons grouper les données en fonction de la commune, donc “libelleCommuneEtablissement”, puis effectuer la somme des lignes regroupées dans chaque commune (puisque 1 ligne = 1 commerce dans nos données).

commerce_commune = summarise(group_by(data42_alim, libelleCommuneEtablissement), somme_ali=n(), .groups="drop")

Les communes comptant le plus de commerces dans le 42 sont donc :

Ce résultat n’est guère suprenant puisqu’il s’agit de communes importantes.

Il est également intéressant de considérer la question opposée, puisque certaines petites communes ne comportent que très peu de commerces. Parmi celles-ci, certaines n’en comptent-elles qu’un seul ? De quel type est-il ? Pour effectuer cette analyse, plusieurs opérations successives sont nécessaires. D’abord, il faut utiliser la fonction de résumé décrite précédemment, afin de regrouper à nouveau les commerces par commune d’appartenance, et effectuer leur total respectif. Puisque nous voulons également obtenir la catégorie de l’unique commerce, il ne faut pas oublier d’inclure “TypeAbreg” dans les colonnes à inclure dans le résumé.

nb_type = filter(summarise(group_by(data42_alim, libelleCommuneEtablissement), sum_mag=n(), TypeAbreg, .groups="drop"), sum_mag==1)

Dans un second temps, la résumé effectué va être filtré afin de ne garder que les communes ne comptant qu’un seul commerce. Pour cela, le filtre va interroger le total de commerces par commune calculé lors du résumé, et lui indiquer que l’on ne souhaite garder que les lignes ayant 1 pour résultat. Les communes avec un seul commerce ainsi que leur type sont donc :

Au total, si l’on additionne le nombre d’établissements présents dans les communes à commerce unique, il s’avère que les catégories les plus représentées sont les restaurants et les bars.

Il est également possible d’analyser les données à travers plusieurs filtres successifs. Par exemple, nous allons chercher à afficher les communes ayant plus de 100 commerces et au moins 10 commerces consacrés à la viande parmi ceux-ci. Pour cela, nous allons construire une chaîne qui comprend le groupement des commerces par communes, le filtre n’incluant que les communes ayant un total de commerces supérieur à 100, et un second filtre permettant de n’inclure que les commerces de type “viande”. La chaîne se poursuit avec l’utilisation de la fonction “résumé”, qui se charge une nouvelle fois de regrouper les données restantes (les commerces de viande uniquement) par commune en calculant le total d’établissements regroupés, et une dernière fonction de filtre permet de ne garder que les communes ayant un total de 10 commerces de viande, ou plus.

cent_mag = data42_alim %>%
  group_by(libelleCommuneEtablissement) %>%
  filter(n()>100, TypeAbreg=="viande") %>%
  summarise(sum_viande=n()) %>%
  filter(sum_viande>10)

Le résultat de cette manipulation nous donne cinq communes uniquement - des communes assez importantes ce qui donne une sens à ce résultat.

Nettoyage des données

Dans un premier temps, nous allons donc créer une fonction permettant de nettoyer les données de n’importe quel département. La fonction est donc découpée en plusieurs étapes. D’abord, une ligne permet d’introduire le fichier CSV des données en fonction d’un numéro en entrée qui s’ajoute dans le nom du fichier à rechercher dans le répertoire via la fonction “paste0” (le 0 supprimant les espaces superflus). La ligne suivante se charge de lire les données ; la suivante découpe le code d’activité afin de le faire correspondre, dans la ligne du dessous, aux codes présents dans “APE_type”, les données étant mises en relation grâce à un filtre. Ensuite, la fonction vient effectuer une jointure attributaire afin d’ajouter les intitulés APE, et une dernière ligne prend soin de transformer les chiffres (en particulier les codes postaux) en chaînes de caractères, afin d’éviter les bugs par la suite à cause d’une lecture erronnée de la part de RStudio.

get_clean_data <- function(num_dpt){
  data = paste0("geo_siret_",num_dpt, ".csv")
  data_dpt = readr::read_csv(data)
  data_dpt$Code = str_sub(data_dpt$activitePrincipaleEtablissement,start=1,end=4)
  alim = filter(data_dpt, data_dpt$Code %in% APE_type$Code)
  data_alim = merge(alim, APE_type, by=c("Code", "Code"))
  data_alim = data.frame(lapply(data_alim, as.character), stringsAsFactor=FALSE)
}

Création d’une boucle pour classifier tous les commerces et export conditionnel du fichier

Nous allons ensuite utiliser cette fonction au sein d’une boucle, permettant de traiter tous les départements qui nous intéressent à la fois. Lors de cette boucle, nous avons également inclus un test de routine, permettant de vérifier si le fichier complet existe déjà dans le répertoire (dans le cas d’utilisations répétées du code). Si le fichier n’existe pas, alors la fonction sera utilisée pour chacun des départements dont les noms sont contenus dans une liste établie au préalable. L’actionnement de cette fonction et de la liste est permise par la fonctionnalité “map” de la librairie “purrr”. Une fois le fichier complet créé et combiné avec “bind_rows”, quelques modifications supplémentaires y seront appliquées. D’abord, une colonne comprenant le numéro du département de chaque commerce est créé à partir de la colonne contenant les codes postaux. Il suffit de ne conserver que leurs deux premiers caractères pour obtenir le résultat voulu. Ensuite, une nouvelle transformation des données numériques en données textuelles est effectuée, même si celle-ci est déjà comprise dans la fonction, afin de modifier la nouvelle colonne en particulier. Enfin, le fichier créé est enregistré dans le répertoire.

library(purrr)
list_dpt = c("01", "38", "42", "43", "69")
if(file.exists("alimRA_entr.csv")){
  alimRA_entr = readr::read_csv("alimRA_entr.csv")
  }else{
  alimRA_entr = purrr::map(list_dpt, get_clean_data)
  alimRA_entr = dplyr::bind_rows(alimRA_entr)
  alimRA_entr$Dept = str_sub(alimRA_entr$codePostalEtablissement,start=1,end=2)
  alimRA_entr = data.frame(lapply(alimRA_entr, as.character), stringsAsFactor=FALSE)
  write.csv(alimRA_entr,"alimRA_entr.csv")
  }

Agrégation des données par commune et type de commerce

Nous allons ici, par exemple, calculer la proportion de chaque type de commerce par commune. Pour cela, plusieurs étapes sont nécessaires. D’abord, nous allons calculer le nombre de commerces par type et par commune (nInTypeCom), ainsi que le nombre de commerces par commune en parallèle (nInCom), toutes les deux via un résumé qui regroupera les catégories voulues et effectuera le total de celles-ci. Ensuite, les deux tables créées sont jointes par un “left_join” en fonction du nom des communes, afin de rassembler les différents totaux créés. Dans cette nouvelle table, une nouvelle colonne correspondant à la proportion de chaque type de commerce dans chaque commune est créée et calculée. Le résultat est visible dans le tableau ci dessous :

#Nombre de commerces par type et par commune
alimRA_InType = summarise(group_by(alimRA_entr, libelleCommuneEtablissement, TypeAbreg), nInTypeCom=n(), .groups="drop")
#Nombre de commerces par commune
alimRA_InCom = summarise(group_by(alimRA_entr, libelleCommuneEtablissement), nInCom=n(), .groups="drop")
#Jointure des deux tables
alimRA_typeCom = left_join(alimRA_InCom, alimRA_InType, by = "libelleCommuneEtablissement")
#Création d'une colonne de proportions
alimRA_typeCom$propInTypeCom = (alimRA_typeCom$nInTypeCom/alimRA_typeCom$nInCom)*100

Nous pouvons ensuite lancer un filtre, pour par exemple récupérer les communes ayant plus de 100 commerces et dont 5% d’entre eux sont des commerces de viande. Pour cela, une chaîne permet de regrouper les commerces par commune, puis de filtrer les données par leur nombre total de commerces et leur proprotion d’établissements de type “viande”.

commerce_viande = alimRA_typeCom %>%
  group_by(libelleCommuneEtablissement) %>%
  filter(nInCom>100, TypeAbreg=="viande", propInTypeCom>5)

Au final, les communes concernées par ces filtres sont les suivantes :

Proportions des commerces par type à Lyon 4e et

Afin d’offrir une meilleure compréhension de nos analyses, nous allons maintenant visualiser nos données. Dans un premier temps, des graphiques peuvent être suffisants afin de représenter et comparer les proportions calculées précédemment. Le graphique ci-dessous représente donc les proprotions de chaque type de commerce en comparant les “communes” de Lyon 4 et Lyon 8.

lyon = c("LYON 4EME", "LYON 8EME")
alim_lyon = filter(alimRA_typeCom, libelleCommuneEtablissement==lyon)

Pour réaliser ce graphique, nous avons utilisé ggplot2 et son graphique “geom_point”. Nous avions au préalable utilisé un filtre afin de ne garder, dans une nouvelle table, que les deux communes nous intéressant (inscrites dans une liste). Il apparaît donc que dans les deux cas, les restaurants occupent la part la plus importante des commerces avec plus de 40% de représentation, une part légérement plus importante à Lyon 8. D’autres commerces, en revanche, varient de manière plus marquée. On trouve ainsi plus de traiteurs à Lyon 8 qu’à Lyon 4. Pour les autres commerces, leur part est si similaire que leurs points sont superposés.

Classement des commerces par année de création

Nous pouvons donc classer les commerces par année de création, par exemple. Pour cela, il nous faut d’abord créer une variable plus exploitable que les dates précises en DD/MM/YYYY fournies dans les données. La librairie “Lubridate” est utile dans ce cas de figure : elle nous permet de convertir nos données en format de “date” YYYY/MM/DD (celles-ci étant précédemment en chaine de caractères), et de récupérer la partie “YYYY” uniquement. Ainsi, nous pouvons créer une nouvelle colonne contenant l’année de création.

alimRA_entr$dateCreationEtablissement = ymd(alimRA_entr$dateCreationEtablissement)
alimRA_entr$annee = year(alimRA_entr$dateCreationEtablissement)

Par la suite, il s’agit d’effectuer plusieurs résumés permettant de calculer les totaux de créations d’entreprises par type et par année (nInTypeAn), ansi qu’un total général par année (nInAn). Comme précédemment, ces deux tables provisoires sont jointes afin de regrouper toutes les indicateurs. Nous pouvons ensuite utiliser un filtre sur cette nouvelle classification, nous permettant d’exclure tous les commerces ayant été créés avant 1970.

type_annee = summarise(group_by(alimRA_entr, annee, TypeAbreg), nInTypeAn=n(), .groups="drop")
nb_annee = summarise(group_by(alimRA_entr, annee), nInAn=n(), .groups="drop")
alimRA_typeAn = left_join(type_annee, nb_annee, by = "annee")
alimRA_typeAn = filter(alimRA_typeAn, annee >=1970)

Nous pouvons ici avoir un aperçu du résultat de cette classification et du filtre :

Evolution de la proportion d’entreprises par type et par année

Une représentation temporelle des données précédemment éditées est donc possible, toujours avec ggplot. Dans un premier graphe, nous souhaitons représenter l’évolution de la proportion d’entreprises créées par année et par type (toutes communes comprises). Pour une telle représentation, nous avons choisi de compiler deux graphiques : des points et des lignes afin d’accentuer les variations.

alimRA_typeAn$prop = (alimRA_typeAn$nInTypeAn*100)/alimRA_typeAn$nInAn

Ce graphique apparaît peu clair ; nous allons l’alléger en ne gardant que les cinq types de commerces prévalents. Pour cela, nous allons créer une chaîne qui va résumer les données par type de commerce, faire le total de création par type (toutes années confondues) à partir de l’indicateur du total par année créé précédemment, classer les données résultantes par ordre décroissant, et tronquer les données pour ne garder que les cinq premières entités.

Il a ensuite suffit de stocker la colonne contenant les noms des catégories du “top 5” dans une liste. Celle-ci servira ensuite de référence pour le filtre permettant de n’inclure que les commerces correspondant aux catégories à représenter.

top5 <- summarise(group_by(alimRA_typeAn, TypeAbreg), total=sum(nInAn), .groups="drop") %>%
  arrange(desc(total)) %>%
  slice(1:5)
top5 = c(top5$TypeAbreg)
top5plot = filter(alimRA_typeAn, TypeAbreg==top5)

Localisation des boulangeries-pâtisseries

Tout d’abord, nous allons développer une carte de localisation des boulangeries-pâtisseries. Au préalable, quelques modifications ont été nécessaires au sein des données, notamment pour transformer notre table en objet spatial “sf”, et supprimer les lignes n’ayant pas de coordonnées complètes (en repérant les lignes n’ayant le champ “latitude” vide).

alim_sf = alimRA_entr[!is.na(alimRA_entr$latitude), ]
alim_sf = st_as_sf(alim_sf, coords=c("longitude","latitude"), crs=4326, stringsAsFactors = FALSE)

Ensuite, après un filtre pour ne garder que les entités concernant les boulangeries, la librairie “tmap” est utilisée pour cartographier les données. Pour des raisons d’esthétique, le fond de carte est modifié, ainsi que le style des points, leur discrétisation, et le zoom initial ; un titre est également ajouté à la carte.

alim_sf_boul = filter(alim_sf, TypeAbreg=="boulPatiss")
tmap_mode("view")

Proportion des commerces par commune dans la région Auvergne-Rhône-Alpes

Pour finir, nous allons cartographier la proportion des commerces par commune dans toute notre région. Pour cela, l’ajout d’une couche shapefile contenant les polygones des communes Françaises est nécessaire. Afin de faire correspondre les données de cette couche à nos données des commerces, nous devons créer un identifiant commun aux deux fichiers. Nous allons donc éditer le code INSEE présent dans le shapefile, afin de n’en garder que les deux premiers chiffres qui correspondent au numéro du département. Ensuite, la liste utilisée lors de l’itération pour créer la table commune à tous les départements est ici réutilisée dans le cadre d’une sélection attributaire, pour ne garder que les communes concernées par l’étude. Le fichier shapefile est enfin transformé en objet sf (son insertion en tant qu’objet sf ne fonctionnant pas dès le début).

library("rgdal")
library("rgeos")
limites_communes <- readOGR("C:/Users/zcami/Documents/MASTER 2/R_stats/SHAPE_COMMUNE/communes-plus-20140630-100m.shp", "communes-plus-20140630-100m")

## OGR data source with driver: ESRI Shapefile 
## Source: "C:\Users\zcami\Documents\MASTER 2\R_stats\SHAPE_COMMUNE\communes-plus-20140630-100m.shp", layer: "communes-plus-20140630-100m"
## with 36725 features
## It has 17 fields

limites_communes$insee <- str_sub(limites_communes$insee, start=1, end=2)
limites_communes <- limites_communes[limites_communes$insee %in% list_dpt, ]
limites_communes_sf <- st_as_sf(limites_communes, coords, crs=4326)

Par la suite, une jointure spatiale est effectuée entre nos données de commerces et le shapefile des communes, afin de faire correspondre chacun des commerces au polygone de sa commune. A partir de ces nouvelles données, il est possible de calculer le total de commerces par commune (grâce à un résumé regroupant les commerces par communes).

Enfin, la carte du nombre de commerces par commune est réalisable de la même manière que la carte précédente. Les communes mises en avant, avec des taux plus importants, sont sans surprise les communes les plus denses de la région.

nb_type_com <- st_join(limites_communes_sf, alim_sf)
alim_com <- summarise(group_by(nb_type_com, nom), nbCo= n(), .groups="drop")